package com.art.base.db;

import android.annotation.SuppressLint;
import android.content.Context;
import android.util.Log;

import com.litesuits.orm.LiteOrm;
import com.litesuits.orm.db.assit.QueryBuilder;
import com.litesuits.orm.db.assit.WhereBuilder;
import com.litesuits.orm.db.model.ColumnsValue;
import com.litesuits.orm.db.model.ConflictAlgorithm;

import java.util.Collection;
import java.util.List;

/**
 * 数据库工具类
 */
public class LiteOrmDBUtil {

    public static String DB_NAME = "apps";
    private static LiteOrm liteOrm;
    public static Context mContext;
    public static boolean isDebug = true;

    /**
     * 数据库名称
     *
     * @return
     */
    private static String getDatabaseName() {
        //数据库位置
        return DB_NAME;
    }

    /**
     * 创建数据库细节 ：
     * 细节一：每次启动都会调用这个方法，是否会重复创建，或者说怎么判断这个数据库已经存在。
     * 回答：尽在第一次创建，开发这不用关心存在否。
     * <p>
     * 细节二：如果指定目录创建在SD卡上，卸载APP之后，重新安装，以前的创建的数据库还存在
     * 回答：如果不想这样，就不要指定创建在SD卡上面，默认创建就在APP里。卸载后数据库就不存在了
     * <p>
     * 细节三：创建数据库有两种模式，第一种是单一操作没有级联关系的，第二种是级联操作。
     * 创建单一操作模式：LiteOrm.newSingleInstance(_activity, DB_NAME);
     * 创建级联操作模式：LiteOrm.newCascadeInstance(_activity, DB_NAME);
     *
     * @param context
     */
    public static boolean createCascadeDB(Context context) {
        mContext = context.getApplicationContext();

        liteOrm = LiteOrm.newCascadeInstance(mContext, DB_NAME);
        liteOrm.setDebugged(isDebug);
        return true;
    }

    public static LiteOrm getLiteOrm() {
        if (liteOrm == null) {
            if (mContext == null) {
                //TODO createDB
            }
            liteOrm = LiteOrm.newCascadeInstance(mContext, getDatabaseName());
        }
        return liteOrm;
    }

    /**
     * 插入一条记录
     *
     * @param t
     */
    public static <T> long insert(T t) {
        return getLiteOrm().save(t);
    }

    /**
     * 插入所有记录
     *
     * @param list
     */
    public static <T> int insertAll(List<T> list) {
        return getLiteOrm().save(list);
    }

    /**
     * 以某种条件作为插入标准
     *
     * @param list
     * @return
     */
    public static <T> long insertAll(Collection<T> t, ConflictAlgorithm config) {
        return getLiteOrm().insert(t, config);
    }

    /**
     * 以某种条件作为插入标准
     *
     * @param list
     * @return
     */
    public static <T> long insertAll(List<T> t, ConflictAlgorithm config) {
        return getLiteOrm().insert(t, config);
    }

    /**
     * 查询所有
     *
     * @param cla
     * @return
     */
    public static <T> List<T> getQueryAll(Class<T> cla) {
        return getLiteOrm().query(cla);
    }

    /**
     * 查询数量
     *
     * @param cla
     * @return
     */
    public static <T> long getCount(Class<T> cla) {
        return getLiteOrm().queryCount(cla);
    }

    /**
     * 根据ID查询
     *
     * @param cla
     * @return
     */
    public static <T> T getInfoById(String id, Class<T> cla) {
        return getLiteOrm().queryById(id, cla);
    }

    /**
     * 根据ID查询
     *
     * @param cla
     * @return
     */
    public static <T> T getInfoById(long id, Class<T> cla) {
        return getLiteOrm().queryById(id, cla);
    }

    /**
     * 查询 某字段 等于 Value的值
     *
     * @param cla
     * @param field
     * @param value
     * @return
     */
    @SuppressWarnings({"unchecked", "rawtypes"})
    public static <T> List<T> getQueryByWhere(Class<T> cla, String field,
                                              String[] value) {
        return getLiteOrm().<T>query(
                new QueryBuilder(cla).where(field + "=?", value));
    }

    /**
     * 查询 某字段 等于 Value的值 可以指定从1-20，就是分页
     *
     * @param cla
     * @param field
     * @param value
     * @param start
     * @param length
     * @return
     */
    public static <T> List<T> getQueryByWhereLength(Class<T> cla, String field,
                                                    String[] value, int start, int length) {
        return getLiteOrm().<T>query(
                new QueryBuilder(cla).where(field + "=?", value).limit(start,
                        length));
    }

    /**
     * 删除所有 某字段等于 Vlaue的值
     *
     * @param cla
     * @param field
     * @param value
     */
    @SuppressWarnings("deprecation")
    public static <T> int deleteWhere(Class<T> cla, String field, String[] value) {
        // liteOrm.delete(cla, WhereBuilder.create().where(field + "=?",
        // value));
        return getLiteOrm().delete(cla,
                WhereBuilder.create(cla, field + "=?", value));
    }

    /**
     * 删除所有
     *
     * @param cla
     */
    public static <T> int deleteAll(Class<T> cla) {
        return getLiteOrm().deleteAll(cla);
    }

    /**
     * 仅在以存在时更新
     *
     * @param t
     */
    public static <T> int update(T t) {
        return getLiteOrm().update(t, ConflictAlgorithm.Replace);
    }

    /**
     * 以某种条件来整体更新
     *
     * @param list
     * @param config
     * @return
     */
    public static <T> int updateAll(List<T> list, ConflictAlgorithm config) {
        return getLiteOrm().update(list, config);
    }

    public static <T> int updateALL(List<T> list) {
        return getLiteOrm().update(list);
    }

    public static <T> void update(Class<T> cla, String queryCol,
                                  String queryValue, String updateCol, String updateValue) {
        int update = getLiteOrm().update(
                new WhereBuilder(cla).where(queryCol + " = ?",
                        new String[]{queryValue}),
                new ColumnsValue(new String[]{updateCol},
                        new Object[]{updateValue}), ConflictAlgorithm.None);
        Log.e(" 更新数据库的信息2", update + "");

    }

    @SuppressLint("NewApi")
    public void closeDB() {
        if (liteOrm != null) {
            liteOrm.close();
        }
    }

    // public static void Text(){
    //
    // //我们把这个对象当做以填充数据的后的对象
    // Conversation mConversation = new Conversation();
    //
    // List<Conversation> list = new ArrayList<Conversation>();
    // for (int i = 0; i < 10; i++) {
    // list.add(mConversation);
    // }
    //
    //
    // //1、插入单条数据
    // LiteOrmDBUtil.insert(mConversation);
    //
    // //2、插入多条数据
    // LiteOrmDBUtil.insertAll(list);
    //
    // //3、查询Conversation表中所有记录
    // List<Conversation> list = LiteOrmDBUtil.getQueryAll(Conversation.class);
    //
    // //4、查询Conversation表中 isVisibility 字段 等于 true 的记录
    // List<Conversation> list =
    // LiteOrmDBUtil.getQueryByWhere(Conversation.class,
    // Conversation.ISVISIBILITY, new String[]{"true"});
    //
    // //5、查询Conversation表中 isVisibility 字段 等于 true 的记录,并且只取20条
    // List<Conversation> list =
    // LiteOrmDBUtil.getQueryByWhereLength(Conversation.class,
    // Conversation.ISVISIBILITY, new String[]{"true"},0,20);
    //
    // //6、删除Conversation表中 isVisibility 字段 等于 true 的记录
    // LiteOrmDBUtil.deleteWhere(Conversation.class,Conversation.ISVISIBILITY ,
    // new String[]{"true"});
    //
    // //7、删除所有
    // LiteOrmDBUtil.deleteAll(Conversation.class);
    //
    //
    // }

}